package com.my.study.collection;

import java.util.concurrent.ConcurrentHashMap;

/**
 * @author Carlos
 * @version 1.0
 * @Description TODO
 * @date 2021/6/22 8:03
 **/
public class TestMap {
    private static final int MAXIMUM_CAPACITY = 1 << 30;

    private static int RESIZE_STAMP_BITS = 16;


    public static void main(String[] args) {

        System.out.println(resizeStamp(3));
    }

    private static void test02() {
        ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<String, Object>(4);
        map.put("s", 1);
        map.put("q", 2);
        map.put("e",3);
        map.put("t",4);
        map.put("w",5);
        map.put("g",6);
        map.put("y",7);
    }

    private static void test01() {
        int HASH_BITS = 0x7fffffff;
        System.out.println(HASH_BITS);
        System.out.println(Integer.numberOfLeadingZeros(HASH_BITS));
    }

    /**
     * 获取大于等于且离传入值最近的2的整数次的数
     *
     * @param c
     * @return
     */
    private static int tableSizeFor(int c) {
        // 为什么减一？
        // 例如传入的c=16，不减1的情况下，直接拿10000运算，得到的是11111，加1->100000 = 32就不对了
        // 为了兼容传入的值本来就是2的整数次方。
        int n = c - 1;
        // 无符号右移1位，与旧值|，逻辑上得到2个1
        n |= n >>> 1;
        // 无符号右移2位，与旧值|，逻辑上得到4个1
        n |= n >>> 2;
        // 无符号右移4位，与旧值|，逻辑上得到8个1
        n |= n >>> 4;
        // 无符号右移8位，与旧值|，逻辑上得到16个1
        n |= n >>> 8;
        // 无符号右移16位，与旧值|，逻辑上得到32个1
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

    /**
     * 返回值作为正在扩容的数据表的size即n的一个标志，rs可以反推出n
     *
     * @param n 数据表的长度
     * @return
     */
    private static int resizeStamp(int n) {
        return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
    }



}
